函数

函数

本章节主要介绍Kotlin中的函数相关的概念。

普通函数

声明

即使Kotlin是一门面向对象的编程语言，它也是有函数的概念的——而不像Java那样，仅仅有“方法”。

Java中有静态方法来代替函数的作用，但是Kotlin的函数比Java的静态方法自由度大很多。我们先来看几个例子。

函数声明使用fun保留字，语法比较类似Scala：

fun function() { 
  println("This is a function") 
}

如果你需要一个有参数的函数：

fun functionWithParams(obj: Any?) { 
  println("You have passed an object to this function: $obj") 
}

上面的函数有一个Any?类型的参数。类似的例子还有程序的入口main函数：

fun main(args: Array<String>) { 
}

如果你需要一个返回值的话：

fun functionWithReturnValue(): Int { 
  return Random().nextInt() 
}

如果一个函数不返回东西，你可以不写返回值。也可以让它显示返回Unit：

fun functionReturnsUnit(): Unit { 
}

如果一个函数不会返回（也就是说只要调用这个函数，那么在它返回之前程序肯定GG了（比如一定会抛出异常的函数）），因此你也不知道返回值该写啥，那么你可以让它返回Nothing：

fun functionReturnsNothing(): Nothing { 
  throw RuntimeException("") 
}

一个函数也可以拥有Java风格的泛型参数：

fun <T> functionWithGenericsParam(t: T): T { 
  return t 
}

Kotlin中的泛型概念和Java基本相同，这里不再展开讨论。关于型变、协变等Java中没有的复杂泛型概念将在下文讨论。

函数参数可以有默认值（关于这个函数中for循环的中缀语法下文会提到，这里可以先忽略）：

fun functionWithDefaultParams(limit: Int = 10): Int { 
  for (i in 0..limit step 2) println(i) 
  return limit 
}

于是你不再需要像Java那样为了默认参数而写一大长串重载函数了。当然，Kotlin也支持重载。

如果一个函数的函数体只需要一个表达式就可以计算出来，比如考虑如下函数：

fun functionReturningIncreasedInteger(num: Int): Int { 
  return num + 1 
}

你可以直接使用这种语法（expression function body）：

fun functionReturningIncreasedInteger(num: Int) = num + 1

第二种语法省略了返回值类型（编译器可以根据后面的表达式推导出返回类型），以及大括号。

同理，比如说我们有一个求平方的函数：

fun square(int: Int) = int * int

如果一个函数是空函数，比如Swing的ActionListener强制要求重载但是又不需要使用的函数，可以通过这种方式来表达：

其中， fun xxx() = Unit 表示这是一个空函数。

如果一个函数不返回Unit或者Nothing，那么尽可能让它成为一个纯函数（即没有副作用的函数）。这是函数式编程的约定。

关于函数式编程：函数式编程是一种学院派的编程范式，与之对应的是“命令式编程”。它常常与数学中的范畴论（category theory）结合，追求编写更易维护、并发性更好的程序。业界对它褒贬不一，笔者倾向于将它与面向对象编程结合。

虽然Hadi Hariri曾经在JetBrains中国开发者日上说过Kotlin不是函数式编程语言，但是Kotlin有大量的（看起来非常）函数式的特性、约定、标准库函数。因此我们可以默认它是追求函数式编程的，那么就应该尽可能遵循函数式法则。

为什么返回Unit或者Nothing就不需要纯了呢？

既然一个函数没有返回值，那么对它讨论引用透明也就没有意义了。如果一个返回Unit或者Nothing的函数没有副作用，那么它的存在也将没有意义。

更多关于函数式编程的知识不在本书讨论范围内，读者可以自行查询相关资料。

内部函数

函数里面也可以定义函数：

内部函数可以直接访问外部函数的局部变量、常量，Java是做不到这点的哦。

递归也没有任何问题。如上面的代码所示。

方法

方法是一种特殊的函数，它必须通过类的实例调用，也就是说每个方法可以在方法内部拿到这个方法的实例。这是方法和函数的不同之处。

方法和函数几乎一模一样，唯一的区别就是方法必须声明在类里面。下面是一个方法和一个函数：

fun thisIsAFunction() = Unit 
　 
class ThisIsAClass { 
  fun thisIsAMethod() = Unit 
}

中缀表达式

可能你会好奇上面给出的一个例子中有一个for循环使用的诡异语法，即中缀表达式：

这个step是什么意思呢？

其实是Kotlin方法的一种语法糖，一个方法如果在声明时有一个infix修饰符，那么它可以使用中缀语法调用。

所谓中缀语法就是不需要点和括号的方法调用：

同理，我们只需要给一个类增加一个中缀的step方法就可以实现上面的语法：

class A { 
  infix fun step(step: Int) = Unit 
} 
　 
fun main(args: Array<String>) { 
  val a = A() 
  a step 2 
}

这个功能基本就是用于将代码变得“更易阅读”。 Scala所有函数缺省支持中缀表达式，Kotlin需要单独声明。

操作符重载

中缀表达式可以在一定程度上简化函数调用的代码。如果说中缀表达式还不够简洁，那么你一定需要操作符重载了。

Kotlin的操作符重载的规则是：

该方法使用operator修饰符
该方法的方法名必须被声明为特定的名称，以将对应的操作符映射为这个函数的调用
参数必须符合该操作符的规定，比如+的重载就不能有多于一个（不含）的参数，也不能为空参数。

举个例子，我们要重载A类的+运算符。注意三个规定（函数名、参数得符合规矩，加operator修饰）：

class A { 
  operator fun plus(a: A) { 
    println("invoking plus") 
  } 
}

这就是对+的重载了。我们可以这样调用这个函数：

val a = A() + A()

此处的+就是对plus方法的调用了。我们可以运行上面的代码，看到输出：”invoking plus”。

当然，操作符重载也可以被替换为函数调用：

val a = A().plus(A())

这段代码和上面那段完全相同。

还有不少操作符的重载，下面给出一系列例子（仅作为函数名的实例，实现全部为空/false/0（因为部分操作符重载要求返回Int/Boolean））：

class A { 
  operator fun plus(a: A) = Unit 
  operator fun minus(a: A) = Unit 
  operator fun times(a: A) = Unit 
  operator fun div(a: A) = Unit 
  operator fun rem(a: A) = Unit 
  @Suppress("DEPRECATED_BINARY_MOD") 
  @Deprecated("mod should be replaced with rem", ReplaceWith("rem")) 
  operator fun mod(a: A) = Unit 
  operator fun rangeTo(a: A) = Unit 
　 
  operator fun get(index: Int) = Unit 
  operator fun get(index1: Int, index2: Int) = Unit 
  operator fun set(index: Int, value: Any?) = Unit 
  operator fun set(index1: Int, index2: Int, value: Any?) = Unit 
　 
  operator fun invoke(obj: Any?) 
　 
  operator fun inc() = A() 
  operator fun dec() = A() 
  operator fun unaryPlus() = A() 
  operator fun unaryMinus() = A() 
　 
  operator fun compareTo(other: Any?) = 0 
  override operator fun equals(other: Any?) = false 
　 
  operator fun contains(element: Any?) = false 
　 
  operator fun iterator() = object : Iterator<Any> { 
    override operator fun hasNext() = false 
    override operator fun next() = Unit 
  } 
}

首先是最基本的操作符，它们对应的操作符和注释中的一一对应：

class A { 
  operator fun plus(a: A) = Unit // + 
  operator fun minus(a: A) = Unit // - 
  operator fun times(a: A) = Unit // * 
  operator fun div(a: A) = Unit // / 
  operator fun rem(a: A) = Unit // % 
　 
  @Suppress("DEPRECATED_BINARY_MOD") 
  @Deprecated("mod should be replaced with rem", ReplaceWith("rem")) 
  operator fun mod(a: A) = Unit // %，和rem一样 
　 
  operator fun rangeTo(a: A) = Unit // .. 
}

倒数第二个mod是特殊的操作符重载——它在Kotlin1.1中被标记为过时（Deprecated）的。在1.1中，使用了rem（remainder）来代替mod，符合java.math.BigInteger的命名。

关于最后那个rangeTo有些不符合人的直觉，下面讲到contains的时候会一起提到，读者可以暂时放下这个问题。

然后是下标访问操作符：

class A { 
  operator fun get(index: Int) = Unit 
  operator fun get(index1: Int, index2: Int) = Unit 
  operator fun set(index: Int, value: Any?) = Unit 
  operator fun set(index1: Int, index2: Int, value: Any?) = Unit 
}

get接收任意数量的int参数，假设它们是index1, index2, index3（以此类推），那么对应的操作符就是对应维数个下标的访问。比如以下例子，操作符对应的方法调用写在行尾注释里了：

fun main(args: Array<String>) { 
  val a = A() 
  a[1] // a.get(1) 
  a[1][2] // a.get(1, 2) 
}

对应的set接收任意数量个int，以及一个任意类型的对象，表示将下标访问作为左值并赋值：

fun main(args: Array<String>) { 
  val a = A() 
  a[1] = 233 // a.set(1, 233) 
  a[1][2] = "666" // a.set(1, 2, "666") 
}

invoke方法允许你把一个Kotlin对象当作Lambda表达式来使用。关于什么是Lambda表达式下文会专门介绍。

class A { 
  operator fun invoke(obj: Any?) 
} 
　 
fun main(args: Array<String>) { 
  val a = A() 
  a(obj) // 实际上调用了 a.invoke(obj) 
  // 还可以 
  A()(obj) 
}

自增自减运算符就更简单了，它们必须返回自己所在类的子类型。这里直接在注释里面写出对应的操作符表达：

// 假设a是A的一个实例 
class A { 
  operator fun inc() = A() // a++ 
  operator fun dec() = A() // a-- 
  operator fun unaryPlus() = A() // ++a 
  operator fun unaryMinus() = A() // --a 
}

还有比较运算符，这是一个特殊的操作符重载，一个函数将会生成一组操作符。有一个特殊情况，就是相等的判断。

考虑以下代码：

class A { 
  operator fun compareTo(other: Any?) = 0 
  override operator fun equals(other: Any?) = false 
}

当一个类只有compareTo没有equals的时候，所有的六个比较运算符（<, >, <=, >=, ==, !=）会被全部代理给compareTo函数的返回值和0的大小比较：

fun main(args: Array<String>) { 
  A() > A() // A().compareTo(A()) > 0 
  A() < A() // A().compareTo(A()) > 0 
  A() >= A() // A().compareTo(A()) >= 0 
  A() <= A() // A().compareTo(A()) <= 0 
  A() == A() // A().compareTo(A()) == 0 
  A() != A() // A().compareTo(A()) != 0 
}

如果有equals，==和!=两个操作符会被代理给equals方法，其余不变。

fun main(args: Array<String>) { 
  A() == A() // A().equals(A()) 
  A() != A() // !A().equals(A()) 
}

有一个操作符，这个操作符不是严格意义上的“操作符”，但它比起其它的操作符重载，它还多了一个特权。它就是in操作符。

class A { 
  operator fun contains(element: Any?) = false 
}

它要求返回Boolean，传入一个参数。调用的话使用in：

fun main(args: Array<String>) { 
  val ls = listOf(12, 233, 43) 
  println(233 in ls) 
}

这里的in就是调用了ls的contains方法。这里你可能要问了：既然是使用in这个符合Kotlin函数命名规范的表达，为什么不使用中缀表达式呢？

想清楚了，我们暂且不说in其实是Kotlin保留字这个问题，中缀表达式的语法是：

fun main(args: Array<String>) { 
  a.func(b) 
  // 变成 
  a func b 
  // 它不能变成 
  // b func a 
  // 上面那个是错的，会变成b.func(a) 
}

但是a in b其实是调用了b的一个方法，因此中缀表达式无法实现这个in。

前面说到contains操作符有一个特权，我们来看看这个特权。还记得when语句吗？它非常灵活，比Java风格的switch不知道高到哪里去了。这里先看一个基本用法：

fun main(args: Array<String>) { 
  val a = Random(System.currentTimeMillis()).nextInt() 
  when (a) { 
    1 -> { /* codes */ 233 } 
    2 -> 233 
    else -> 666 
  } 
}

它可以配合contains方法：

fun main(args: Array<String>) { 
  val a = Random(System.currentTimeMillis()).nextInt() 
  when (a) { 
    in 1..100 -> 233 
    is Int -> 2333 
    else -> 666 
  } 
}

看到了吗？in还可以这样写哦。

还有一组运算符，它们将被编译为相同的一个操作符，也是in，只不过场合不同。

class A { 
  operator fun iterator() = Unit 
  operator fun hasNext() = false 
  operator fun next() = Unit 
}

这个in是用于for-in循环的。上面例子中的for循环使用的是这个in操作符。

一个标准的Kotlin风格的for循环应该是下面这样的：kotlin fun main(args: Array<String>) { for (i in 1..10) println(i) }

它和下面的代码完全等价：

fun main(args: Array<String>) { 
  val range = 1..10 
  val item = range.iterator() 
  while (item.hasNext()) { 
    println(item.next()) 
  } 
}

还记得那个step吗？它其实是对1..100调用了一个中缀的方法step。这下读者对于前面遗留的疑问就全部解决了。

Kotlin关于操作符重载的内容确实比较繁杂，但是比起C++的操作符重载还是要强大那么一点点的（C++没有in这种操作符）。

Lambda表达式

好了这是函数式编程的重头戏——Lambda表达式。

Lambda表达式俗称匿名函数，熟悉Java的大家应该也明白这是个什么概念。Kotlin的Lambda表达式更“纯粹”一点，因为它是真正把Lambda抽象为了一种类型，而Java只是单方法匿名接口实现的语法糖罢了。

Lambda在Java中非常常用，这里不再单独介绍它。

Lambda表达式最常用的地方之一是为GUI控件设置监听器：

还有调用集合框架抽象出来的高阶函数（Higher Order Function）：

上面的代码可能会令读者产生疑惑，那个it是什么鬼？

it是Kotlin为单参数的Lambda钦定的默认参数名。单参数的Lambda可以省去参数的声明，转而使用it这个名字。

首先，我们有无参数的Lambda表达式：

fun main(args: Array<String>) { 
  { } 
}

你可以直接把它写在外面，并且把它当成对象使用。Lambda对象有缺省的invoke函数的实现，也就是调用这个Lambda：

fun main(args: Array<String>) { 
  { println("invoking lambda") }.invoke() 
}

你也可以使用操作符重载的方式调用invoke函数：

fun main(args: Array<String>) { 
  { println("invoking lambda") }() 
}

如果一个Lambda有参数，那么需要使用这样的语法声明：

如果有多个参数：

Lambda变量的签名不需要写参数名，只需要写类型。Lambda的返回值就是最后一个表达式的返回值。就像这样：

fun main(args: Array<String>) { 
  // 只需要写类型，我没骗你吧 
  val value: (String, Int) -> Int 
  value = { str: String, num: Int -> 
    println("num = $num, str = $str") 
    num 
  } 
  value("the deep dark fantasy", 233) + 1 
}

如果Lambda的参数、返回值类型不匹配，互相赋值是会报错的哦。

当然，Lambda经常作为函数参数使用。

如果一个Lambda是一个函数的最后一个参数，Kotlin为这种情况专门提供了一个语法糖。
Lambda在作为匿名变量传递给函数时，不需要显式声明参数类型（因为可以根据函数参数那里的类型签名推导）。

上面两句话如何理解呢？比如你有一个自定义UI控件：

class KotlinButton : View() { 
  fun setOnClickListener(block: (View) -> Unit) { 
    // set 
  } 
}

然后调用的时候就可以使用这个语法糖了：

class MainActivity : AppCompatActivity() { 
  override fun onCreate(save: Bundle?) { 
    val a = KotlinButton() 
    // 原本是： 
    // a.setOnClickListener({ view -> 
    //   toast("Clicked") 
    // }) 
    // 语法糖省去了表示参数的括号，直接写Lambda 
    a.setOnClickListener { view -> 
    // 编译器的类型推导省去了 view: View 的类型声明 
      toast("Clicked") 
      view.text = "Oh my god" 
    } 
  } 
}

上面那段代码是Android的，熟悉的API看出来了吗？

你甚至还可以把那个view参数的声明给省了，因为只有一个参数，可以使用it代替：

fun main(args: Array<String>) { 
  a.setOnClickListener { 
    toast("Hia hia") 
    it.text = "clicked" 
  } 
}

如果一个函数不只是有一个参数，但是最后一个参数（依然符合条件），那么可以这样写：

fun main(args: Array<String>) { 
  a.callSomeMethods(1, 2, 3) { 
    // do something 
  } 
}

它完全等价于：

fun main(args: Array<String>) { 
    a.callSomeMethods(1, 2, 3, { 
      // do something else 
    }) 
}

如果你不需要用到那个参数，又不想为它命名，那么使用下划线代替它吧。

fun main(args: Array<String>) { 
  a.setOnClickListener { _ -> 
    toast("LOL LOL LOL") 
  } 
}

此时你可能会问：上面那个代码完全可以把整个_ ->给省掉啊？不是说单参数可以省吗？

因为多参数是不能省的（多参数Lambda不写参数会报错），所以它还是很有用的：

fun main(args: Array<String>) { 
  listOf(1, 2, 3).forEachIndexed { _, _ -> 
    println("Looping!") 
  } 
}

最后说的这个下划线的特性是Kotlin1.1才引入的。

请读者注意不要混淆上面的两个“多参数”，第一处说的是函数多参数，第二处说的是Lambda多参数。

我们可以通过Lambda表达式来勉强地实现函数的柯里化：

fun plus(a: Int) = { b: Int -> a + b }

调用就可以这样：

fun main(args: Array<String>) { 
  println(plus(233)(666)) 
}

这有什么用呢？可以实现一个函数的部分应用。

fun main(args: Array<String>) { 
  val a = plus(233) 
  // 然后呱啦呱啦呱啦一堆东西 
  val pluser2 = getIntFromSomewhere() 
  println(a(pluser2)) 
}

和泛型结合之后可以泛化出上面那个函数的抽象：

fun <A, B, C> ((a: A, b: B) -> C).curry() = 
    { a: A -> { b: B -> invoke(a, b) } }

plus就可以这样被抽象出来：

fun main(args: Array<String>) { 
  val plusOrigin = { a: Int, b: Int -> 
    a + b 
  } 
  val a = plusOrigin.curry() 
  a(233)(666) // 和上面那个就是一样的了 
}

我们还可以做出多参数的柯里化的抽象：

fun <A, B, C, D, E, F, G> 
 ((a: A, b: B, c: C, d: D, e: E, f: F) -> G).curry() = 
     { a: A -> { b: B -> { c: C -> { d: D -> { e: E -> 
     { f: F -> invoke(a, b, c, d, e, f) } } } } } }

这样的抽象可以用于更多参数的函数的柯里化：

就是这样。

调用

函数调用写法和Java几乎完全一样，比如调用上面声明的几个函数：

fun main(args: Array<String>) { 
  functionWithGenericsParam(233) 
  functionReturnsNothing() 
}

已经说过了Lambda的invoke写法所以这里不再提及。

当你需要调用一个接收了“有返回值的Lambda”的函数时，这样的写法是会报错的：

fun main(args: Array<String>) { 
  function { 
    println("Hi there!") 
    // 下面这句会报错！ 
    // return 233 
  } 
}

因为这样的return语句在被inline之后，编译器不知道你是要return掉main函数还是这个Lambda。

因此你需要显式声明return的作用域：

fun main(args: Array<String>) { 
  function { 
    println("Hi there!") 
    return@function 233 
  } 
}

这叫做“Label return”，其中return@后面的标签（Label）是你要return的Lambda所传递给的函数名（比如上面就是function）。

如果你的函数名是kotlinIsAwesome，那么你就需要这样写：

fun main(args: Array<String>) { 
  kotlinIsAwesome { 
    return@kotlinIsAwesome 233 
  } 
}

如果你使用IntelliJ IDEA，它会告诉你你需要写什么标签。

内联函数

顾名思义，就是把函数体给内联到调用处。这对程序的逻辑是没有影响的，只是对一些无关逻辑的因素有影响，比如：

运行效率
目标文件体积
重构上的优越性

等等。

比如标准库的一堆函数：

/** Prints the given message to the standard output stream. */ 
@kotlin.internal.InlineOnly 
public inline fun print(message: Any?) { 
    System.out.print(message) 
}

内联函数最好的好处就是直接内联Lambda，不产生匿名内部类对象。这是一个非常黑的黑科技，减少Lambda对象的数量可以既保证函数式的优美代码，又不必为Lambda对象的开销买单。

如果一个内联函数没有内联到Lambda表达式，那么Kotlin编译器会给出一个警告—— 因为inline本身就只是为了inline掉Lambda而准备的特性，标准库会有一些专门用于内联的函数（后面会讲到）。 inline一些无关紧要的函数反而会导致无谓的体积增加（JVM本身就会在运行时内联不少函数）。

Kotlin-discussion曾经出现过一个帖子，楼主说他太喜欢inline这个功能了，以至于把大量的大型函数inline的到处都是，最后导致了jar体积的肥大。

crossinline与noinline

crossinline是一种比普通inline更高级的inline方法，它只能修饰Lambda参数，用于处理一些奇怪的Lambda的内部return（有时你只是想return掉Lambda，但是内联后会导致return掉外部context）。

Kotlin编译器使用了一些奇怪的方法来复用内联Lambda产生的参数。

fun crossInlineFunction(crossinline f: () -> Unit) { 
  f.invoke() 
}

noinline也只能用于修饰Lambda参数，表示在内联这个函数的情况下，不对这个Lambda进行内联优化（即：依然针对Lambda产生一个匿名内部类对象，开销和Java的就一样了。有些情况编译器无法内联这个Lambda，只能提示你加上noinline。这里不再展开讲解）。

fun noInlineFunction(noinline f: () -> Unit) { 
  f.invoke() 
}

因此，请读者尽可能遵循标准规定：仅对接收Lambda的函数使用内联。

扩展函数

扩展可谓是Kotlin的“killer feature”，它只是一个语法糖，却是一个（有时）难以理解的语法糖，一般黑带Kotlin程序员会谨慎并大量地使用它。

在IDE的帮助下，扩展对原库的污染已经不再是污染，因为扩展和原方法会被高亮给清晰地区分开。

下文中，有时会把扩展函数称为扩展方法，指的实际上是同一个概念。

普通的扩展函数

说了这么多，扩展到底是什么呢？

就是使用一些语法糖来假装给一些类添加方法，并像真正的方法一样调用它。

为什么要“假装给类添加方法”呢？

你有种给java.io.File类添加一个openOrCreate方法啊？

（以上调侃并不适用于rt.jar开发人员）

你可能还是不能理解这是什么，那么看看下面的例子吧：

fun main(args: Array<String>) { 
  val ls = java.util.ArrayList<Int>() 
  ls.add(233) 
  ls.add(666) 
  ls.add(555) 
  ls.add(1024) 
  val sum = ls.fold(0) { sum, value -> 
    sum + value 
  } 
  println(sum) 
}

以上代码使用Kotlin1.1第一个正式版编译器编译通过。在JRE1.8_101上完美运行。

你肯定知道，java.util.ArrayList是没有fold这个方法的。

那上面的代码是怎么回事？为什么我可以在ls对象上调用一个它本来没有的方法呢？

这完全符合刚才的定义：

像真正的方法一样调用它。

那么我们来看看这个方法怎么实现吧。这里不使用集合框架，而是使用另一个例子：给File类增加一个openOrCreate方法。

首先，我们可以这样：

fun openOrCreate(file: java.io.File) { 
  if (!file.exists()) file.createNewFile() 
}

然后这样调用它：

fun main(args: Array<String>) { 
  openOrCreate(File("./save.txt")) 
}

但是如果我们希望一种更优美的方式，我们可以使用这个语法：

fun File.openOrCreate() { 
  if (!exists()) createNewFile() 
}

卧槽！那个if (!exists())看起来就像是直接写在File类内部的方法一样啊！

其实这里是个小小的trick，编译器会这样处理它：

fun openOrCreate(receiver: File) { 
  if (!receiver.exists()) receiver.createNewFile() 
}

也就是说，如果将fun openOrCreate(receiver: File)写成fun File.openOrCreate()，那么这个函数可以直接调用File类的方法，就像它自己也是一个File类的方法一样。编译过后它会被处理为对receiver的方法调用。

也就是说，这种扩展方法是不能调用private、protected以及internal的属性/方法的（因为它事实上就是一个普普通通的函数罢了）。

我们来看看它的调用吧：

fun main(args: Array<String>) { 
  val file = File("./save.png") 
  file.openOrCreate() 
}

是不是很有趣啊？

而且，在意识到了这只是一个普通方法后，你可能会问：能不能将它当成普通函数而不是方法运行呢？

当然…不可以：

fun main(args: Array<String>) { 
  val file = File("./save.png") 
  openOrCreate(file) // error 
}

当然，你也可以在一个类里面对另一个类进行扩展：

class A(val int: Int) 
class B { 
  fun A.someFunction() { 
    println(int) 
  } 
　 
  fun anotherFunction() { 
    val a = A() 
    a.someFunction() 
  } 
}

这也是合法的。

在一个扩展函数内部，this所指向的就是receiver。

fun File.openOrCreate() { 
  if (!this.exists()) this.createNewFile() 
}

读者可以通过在扩展函数内部调用println(this)来验证。

扩展Lambda

其实扩展还有一种用途，就是使一个Lambda成为“扩展Lambda”：

fun main(args: Array<String>) { 
  val extensionLambda = Int.{ println(this) } 
  233.extensionLambda() // OK 
  extensionLambda(233) // OK 
}

看到了吗？Lambda表达式也可以被理解为是“对一个类进行扩展的Lambda”表达式。也就是说，它也可以像扩展方法一样，从内部拿到一个特定的this，然后将它作为一个扩展使用。

扩展Lambda也可以作为一个函数的参数。

不同于扩展函数，扩展Lambda可以被当作一个非扩展Lambda。

fun applyToFile(block: File.() -> Unit) { 
  val file = File() 
  file.block() // OK 
  block(file) // OK 
}

这么写，没人拦着你，我不会拦着你，编译器也不会拦着你。这个代码和上面的代码都是合法的Kotlin代码。

注意，以上代码仅为演示语法，是没有实际意义的。

我们还可以结合扩展函数和扩展Lambda：将一个扩展Lambda作为一个扩展函数的参数。

fun File.run(block: File.() -> Unit) { 
  this.block() // OK 
  block(this) // OK 
}

this一般可以省略，所以有：

fun File.run(block: File.() -> Unit) { 
  block() 
}

还可以结合Kotlin的“expression body”：

fun File.run(block: File.() -> Unit) = block()

在调用的时候，可以再结合一下Kotlin的Lambda参数语法糖：

fun main(args: Array<String>) { 
  val file = File("./save.log") 
  file.run { 
    if (!exists()) createNewFile() 
  } 
}

这相当于是给File类提供了一个run的工具函数，它可以把一个Lambda应用到file对象。

请读者确保自己能读懂以上代码，它用到了很多Kotlin的（比较）高级的特性：

扩展函数
扩展Lambda
Lambda作为最后一个参数的简化写法

到这里就结束了吗？

不，你可能已经想到了另一个JVM支持的特性，它和扩展结合起来能做到更优美。

还记得吗？这是JVM很早就引入的一个特性。

泛型。

泛型扩展

首先考虑如下代码：

fun <T> runWith(receiver: T, block: T.() -> Unit) { 
  receiver.block() 
}

这个函数用泛型抽象了一个“runWith”的概念，也就是说传入一个对象和一个扩展给该对象的类型的Lambda，然后在这个对象上调用这个Lambda：

我们再结合扩展：

fun <T> T.run(block: T.() -> Unit) { 
  block() // OK 
  this.block() // OK 
  block(this) // OK 
  block.invoke(this) // OK 
}

上面展示了四种截然不同但是完全等价的调用block的方法，读者在抄代码的时候请只保留一个。

这个run变得更玄学了，可以直接在任意类型的任意对象上调用run方法了：

fun main(args: Array<String>) { 
  Random().nextInt(200).run { 
    if (this <= 100) println("smaller than 100, or equaled.") 
    else println("bigger than 100.") 
  } 
}

还记得吗？接收Lambda对象的函数是被建议写为inline的：

inline fun <T> T.run(block: T.() -> Unit) { 
  block() 
}

这样省去了Lambda传递的开销，和朴素写法就完全等价了。

所以亲爱的读者，还记得之前提到的集合框架多出来的fold方法吗？这是内置在Kotlin标准库的扩展函数。

Kotlin的标准库，基本由扩展函数组成。它通过扩展，结合Java标准库本身已经有的一个非常强大的集合框架，通过打包后仅仅700kb的jar作为标准库，却非比寻常的强大。

我们来看看其它JVM语言的做法：

相比之下，Kotlin这种做法是非常友善的（inline零开销，完美利用rt.jar，而且可以随心所欲地扩展）。

关于扩展是否会污染原库的讨论

曾经Kotlin社区有人询问过关于扩展函数是否会污染原库的问题。

JetBrains显然考虑到了这点，他们通过IDE插件将两种方法高亮成了不同颜色，完美区分了普通方法和扩展方法：

如果你是IntelliJ IDEA用户，那么应该早就注意到这一点了。

缺省设置是黄色，可以在这里调整：

一篇文章彻底搞懂 Kotlin 函数

函数